import type { Question } from '@/types/exam';

/**
 * 面向对象编程题目（初级10道 + 中级10道 + 高级10道）
 */
export const oopQuestions: Question[] = [
	// ========== 初级题目（10道） ==========
	{
		id: 2001,
		techId: 'java',
		type: 'single',
		difficulty: 'easy',
		category: '面向对象编程',
		question: 'Java中，以下关于类的说法，正确的是？',
		options: [
			{ key: 'A', text: '一个文件只能有一个类' },
			{ key: 'B', text: '类名必须与文件名相同' },
			{ key: 'C', text: '类是对象的模板' },
			{ key: 'D', text: '类不能有方法' }
		],
		answer: ['C'],
		explanation: '类是对象的模板，定义了对象的属性和方法。一个文件可以有多个类，但public类必须与文件名相同。'
	},
	{
		id: 2002,
		techId: 'java',
		type: 'single',
		difficulty: 'easy',
		category: '面向对象编程',
		question: 'Java中，以下关于继承的说法，正确的是？',
		options: [
			{ key: 'A', text: 'Java支持多重继承' },
			{ key: 'B', text: 'Java只支持单继承' },
			{ key: 'C', text: 'Java不支持继承' },
			{ key: 'D', text: '子类可以继承父类的private成员' }
		],
		answer: ['B'],
		explanation: 'Java只支持单继承，即一个类只能继承一个父类，但可以实现多个接口。子类不能继承父类的private成员。'
	},
	{
		id: 2003,
		techId: 'java',
		type: 'judge',
		difficulty: 'easy',
		category: '面向对象编程',
		question: 'Java中，子类可以重写（override）父类的方法。',
		options: [
			{ key: 'A', text: '正确' },
			{ key: 'B', text: '错误' }
		],
		answer: ['A'],
		explanation: '子类可以重写父类的方法，但方法签名必须相同，访问权限不能缩小，返回值类型可以是父类返回类型的子类。'
	},
	{
		id: 2004,
		techId: 'java',
		type: 'single',
		difficulty: 'easy',
		category: '面向对象编程',
		question: 'Java中，以下哪个关键字用于实现接口？',
		options: [
			{ key: 'A', text: 'extends' },
			{ key: 'B', text: 'implements' },
			{ key: 'C', text: 'interface' },
			{ key: 'D', text: 'abstract' }
		],
		answer: ['B'],
		explanation: 'implements关键字用于实现接口。一个类可以实现多个接口，但只能继承一个类。'
	},
	{
		id: 2005,
		techId: 'java',
		type: 'single',
		difficulty: 'easy',
		category: '面向对象编程',
		question: 'Java中，以下关于封装的说法，正确的是？',
		options: [
			{ key: 'A', text: '封装就是隐藏实现细节' },
			{ key: 'B', text: '封装就是将所有成员设为public' },
			{ key: 'C', text: 'Java不支持封装' },
			{ key: 'D', text: '封装只能用于方法' }
		],
		answer: ['A'],
		explanation: '封装是面向对象三大特性之一，通过访问修饰符（private、protected、public）隐藏实现细节，只暴露必要的接口。'
	},
	{
		id: 2006,
		techId: 'java',
		type: 'judge',
		difficulty: 'easy',
		category: '面向对象编程',
		question: 'Java中，抽象类不能被实例化。',
		options: [
			{ key: 'A', text: '正确' },
			{ key: 'B', text: '错误' }
		],
		answer: ['A'],
		explanation: '抽象类不能被实例化，只能被继承。抽象类可以包含抽象方法和具体方法。'
	},
	{
		id: 2007,
		techId: 'java',
		type: 'single',
		difficulty: 'easy',
		category: '面向对象编程',
		question: 'Java中，以下关于多态的说法，正确的是？',
		options: [
			{ key: 'A', text: '多态就是方法重载' },
			{ key: 'B', text: '多态是指同一个方法在不同对象上有不同表现' },
			{ key: 'C', text: 'Java不支持多态' },
			{ key: 'D', text: '多态只能用于接口' }
		],
		answer: ['B'],
		explanation: '多态是指同一个方法在不同对象上有不同的表现，主要通过继承和重写实现。方法重载是编译时多态，重写是运行时多态。'
	},
	{
		id: 2008,
		techId: 'java',
		type: 'single',
		difficulty: 'easy',
		category: '面向对象编程',
		question: 'Java中，以下哪个关键字用于声明抽象方法？',
		options: [
			{ key: 'A', text: 'abstract' },
			{ key: 'B', text: 'virtual' },
			{ key: 'C', text: 'override' },
			{ key: 'D', text: 'interface' }
		],
		answer: ['A'],
		explanation: 'abstract关键字用于声明抽象方法。抽象方法没有方法体，必须在子类中实现（如果子类不是抽象类）。'
	},
	{
		id: 2009,
		techId: 'java',
		type: 'single',
		difficulty: 'easy',
		category: '面向对象编程',
		question: 'Java中，以下关于接口的说法，正确的是？',
		options: [
			{ key: 'A', text: '接口可以有具体方法（Java 8+）' },
			{ key: 'B', text: '接口不能有常量' },
			{ key: 'C', text: '接口可以被实例化' },
			{ key: 'D', text: '一个类只能实现一个接口' }
		],
		answer: ['A'],
		explanation: '从Java 8开始，接口可以有default方法和static方法。接口可以有常量（默认public static final），不能被实例化，一个类可以实现多个接口。'
	},
	{
		id: 2010,
		techId: 'java',
		type: 'judge',
		difficulty: 'easy',
		category: '面向对象编程',
		question: 'Java中，this关键字用于引用当前对象。',
		options: [
			{ key: 'A', text: '正确' },
			{ key: 'B', text: '错误' }
		],
		answer: ['A'],
		explanation: 'this关键字用于引用当前对象，可以访问当前对象的成员变量和方法，也可以用于调用当前类的构造函数。'
	},

	// ========== 中级题目（10道） ==========
	{
		id: 2011,
		techId: 'java',
		type: 'single',
		difficulty: 'medium',
		category: '面向对象编程',
		question: 'Java中，方法重载（Overload）的要求是？',
		options: [
			{ key: 'A', text: '方法名相同，参数列表不同' },
			{ key: 'B', text: '方法名不同，参数列表相同' },
			{ key: 'C', text: '方法名和参数列表都相同' },
			{ key: 'D', text: '返回值类型不同' }
		],
		answer: ['A'],
		explanation: '方法重载要求方法名相同，但参数列表（参数个数、类型或顺序）必须不同。返回值类型不能作为重载的依据。'
	},
	{
		id: 2012,
		techId: 'java',
		type: 'single',
		difficulty: 'medium',
		category: '面向对象编程',
		question: 'Java中，以下关于super关键字的说法，正确的是？',
		options: [
			{ key: 'A', text: 'super只能调用父类的方法' },
			{ key: 'B', text: 'super可以调用父类的构造函数' },
			{ key: 'C', text: 'super不能用于静态方法' },
			{ key: 'D', text: 'super和this不能同时使用' }
		],
		answer: ['B'],
		explanation: 'super可以调用父类的构造函数（super()）和方法（super.method()）。super不能用于静态方法，super和this可以同时使用。'
	},
	{
		id: 2013,
		techId: 'java',
		type: 'multiple',
		difficulty: 'medium',
		category: '面向对象编程',
		question: '以下哪些是面向对象的特性？',
		options: [
			{ key: 'A', text: '封装' },
			{ key: 'B', text: '继承' },
			{ key: 'C', text: '多态' },
			{ key: 'D', text: '抽象' }
		],
		answer: ['A', 'B', 'C', 'D'],
		explanation: '面向对象的四大特性：封装（隐藏实现）、继承（代码复用）、多态（不同表现）、抽象（提取共性）。'
	},
	{
		id: 2014,
		techId: 'java',
		type: 'single',
		difficulty: 'medium',
		category: '面向对象编程',
		question: 'Java中，以下关于final关键字的说法，错误的是？',
		options: [
			{ key: 'A', text: 'final类不能被继承' },
			{ key: 'B', text: 'final方法不能被重写' },
			{ key: 'C', text: 'final变量不能修改' },
			{ key: 'D', text: 'final方法可以被重载' }
		],
		answer: ['D'],
		explanation: 'final类不能被继承，final方法不能被重写但可以被重载，final变量不能修改（基本类型）或不能重新赋值（引用类型）。'
	},
	{
		id: 2015,
		techId: 'java',
		type: 'single',
		difficulty: 'medium',
		category: '面向对象编程',
		question: 'Java中，以下关于静态成员的说法，正确的是？',
		options: [
			{ key: 'A', text: '静态成员属于实例' },
			{ key: 'B', text: '静态方法可以访问非静态成员' },
			{ key: 'C', text: '静态成员属于类' },
			{ key: 'D', text: '静态方法必须通过实例调用' }
		],
		answer: ['C'],
		explanation: '静态成员属于类，不属于实例。静态方法不能访问非静态成员（需要实例），可以通过类名直接调用。'
	},
	{
		id: 2016,
		techId: 'java',
		type: 'judge',
		difficulty: 'medium',
		category: '面向对象编程',
		question: 'Java中，接口的所有方法默认都是public abstract的。',
		options: [
			{ key: 'A', text: '正确' },
			{ key: 'B', text: '错误' }
		],
		answer: ['A'],
		explanation: '接口中的方法默认是public abstract的（可以省略）。Java 8+允许default和static方法。'
	},
	{
		id: 2017,
		techId: 'java',
		type: 'single',
		difficulty: 'medium',
		category: '面向对象编程',
		question: 'Java中，以下关于构造函数重载的说法，正确的是？',
		options: [
			{ key: 'A', text: '构造函数不能重载' },
			{ key: 'B', text: '构造函数可以重载，但必须调用this()或super()' },
			{ key: 'C', text: '构造函数必须调用父类构造函数' },
			{ key: 'D', text: '构造函数可以返回void' }
		],
		answer: ['B'],
		explanation: '构造函数可以重载，第一个语句必须是this()（调用本类其他构造函数）或super()（调用父类构造函数）。如果不写，默认调用super()。'
	},
	{
		id: 2018,
		techId: 'java',
		type: 'single',
		difficulty: 'medium',
		category: '面向对象编程',
		question: 'Java中，以下关于对象初始化的顺序，正确的是？',
		options: [
			{ key: 'A', text: '静态块 -> 实例块 -> 构造函数' },
			{ key: 'B', text: '构造函数 -> 实例块 -> 静态块' },
			{ key: 'C', text: '实例块 -> 静态块 -> 构造函数' },
			{ key: 'D', text: '顺序不确定' }
		],
		answer: ['A'],
		explanation: '对象初始化顺序：父类静态块 -> 子类静态块 -> 父类实例块 -> 父类构造函数 -> 子类实例块 -> 子类构造函数。'
	},
	{
		id: 2019,
		techId: 'java',
		type: 'multiple',
		difficulty: 'medium',
		category: '面向对象编程',
		question: '以下哪些是Java的访问修饰符？',
		options: [
			{ key: 'A', text: 'public' },
			{ key: 'B', text: 'private' },
			{ key: 'C', text: 'protected' },
			{ key: 'D', text: 'default' }
		],
		answer: ['A', 'B', 'C', 'D'],
		explanation: 'Java有4种访问修饰符：public（任何地方）、protected（包内和子类）、default（包内）、private（类内）。'
	},
	{
		id: 2020,
		techId: 'java',
		type: 'single',
		difficulty: 'medium',
		category: '面向对象编程',
		question: 'Java中，以下关于内部类的说法，正确的是？',
		options: [
			{ key: 'A', text: '内部类不能访问外部类的成员' },
			{ key: 'B', text: '内部类可以访问外部类的私有成员' },
			{ key: 'C', text: '内部类必须是静态的' },
			{ key: 'D', text: '内部类不能有构造函数' }
		],
		answer: ['B'],
		explanation: '内部类可以访问外部类的所有成员（包括私有成员）。内部类可以是静态的或非静态的，可以有构造函数。'
	},

	// ========== 高级题目（10道） ==========
	{
		id: 2021,
		techId: 'java',
		type: 'single',
		difficulty: 'hard',
		category: '面向对象编程',
		question: 'Java中，以下关于方法重写（Override）的规则，错误的是？',
		options: [
			{ key: 'A', text: '方法名和参数列表必须相同' },
			{ key: 'B', text: '返回值类型可以是父类返回类型的子类' },
			{ key: 'C', text: '访问权限可以缩小' },
			{ key: 'D', text: '不能抛出比父类更多的异常' }
		],
		answer: ['C'],
		explanation: '方法重写规则：方法名和参数列表相同，返回值类型可以是子类（协变返回类型），访问权限不能缩小，不能抛出比父类更多的检查异常。'
	},
	{
		id: 2022,
		techId: 'java',
		type: 'single',
		difficulty: 'hard',
		category: '面向对象编程',
		question: 'Java中，以下关于接口默认方法（Java 8+）的说法，正确的是？',
		options: [
			{ key: 'A', text: '默认方法必须被实现' },
			{ key: 'B', text: '默认方法可以被重写' },
			{ key: 'C', text: '默认方法不能有方法体' },
			{ key: 'D', text: '接口不能有多个默认方法' }
		],
		answer: ['B'],
		explanation: '接口默认方法有方法体，可以被实现类重写，也可以不重写直接使用。接口可以有多个默认方法。'
	},
	{
		id: 2023,
		techId: 'java',
		type: 'single',
		difficulty: 'hard',
		category: '面向对象编程',
		question: 'Java中，以下关于函数式接口的说法，正确的是？',
		options: [
			{ key: 'A', text: '函数式接口只能有一个抽象方法' },
			{ key: 'B', text: '函数式接口不能有默认方法' },
			{ key: 'C', text: '函数式接口不能有静态方法' },
			{ key: 'D', text: '所有接口都是函数式接口' }
		],
		answer: ['A'],
		explanation: '函数式接口（@FunctionalInterface）只能有一个抽象方法，但可以有多个默认方法和静态方法。不是所有接口都是函数式接口。'
	},
	{
		id: 2024,
		techId: 'java',
		type: 'multiple',
		difficulty: 'hard',
		category: '面向对象编程',
		question: '以下哪些是Java中实现多态的方式？',
		options: [
			{ key: 'A', text: '方法重载（编译时多态）' },
			{ key: 'B', text: '方法重写（运行时多态）' },
			{ key: 'C', text: '接口实现' },
			{ key: 'D', text: '泛型' }
		],
		answer: ['A', 'B', 'C'],
		explanation: '多态实现方式：方法重载（编译时）、方法重写（运行时）、接口实现。泛型是类型参数化，不是多态。'
	},
	{
		id: 2025,
		techId: 'java',
		type: 'single',
		difficulty: 'hard',
		category: '面向对象编程',
		question: 'Java中，以下关于桥接方法（Bridge Method）的说法，正确的是？',
		options: [
			{ key: 'A', text: '桥接方法是编译器自动生成的' },
			{ key: 'B', text: '桥接方法用于泛型类型擦除后的类型兼容' },
			{ key: 'C', text: '程序员需要手动编写桥接方法' },
			{ key: 'D', text: '桥接方法只用于接口' }
		],
		answer: ['B'],
		explanation: '桥接方法是编译器为了处理泛型类型擦除而自动生成的方法，确保类型安全。程序员不需要手动编写。'
	},
	{
		id: 2026,
		techId: 'java',
		type: 'single',
		difficulty: 'hard',
		category: '面向对象编程',
		question: 'Java中，以下关于代理模式的说法，错误的是？',
		options: [
			{ key: 'A', text: '静态代理需要手动编写代理类' },
			{ key: 'B', text: '动态代理使用反射机制' },
			{ key: 'C', text: 'JDK动态代理只能代理接口' },
			{ key: 'D', text: 'CGLIB代理不能代理接口' }
		],
		answer: ['D'],
		explanation: '静态代理需要手动编写代理类；JDK动态代理只能代理接口，使用反射；CGLIB可以代理类，通过继承实现。'
	},
	{
		id: 2027,
		techId: 'java',
		type: 'judge',
		difficulty: 'hard',
		category: '面向对象编程',
		question: 'Java中，接口可以继承多个接口。',
		options: [
			{ key: 'A', text: '正确' },
			{ key: 'B', text: '错误' }
		],
		answer: ['A'],
		explanation: '接口可以继承多个接口，使用extends关键字。例如：interface A extends B, C, D {}'
	},
	{
		id: 2028,
		techId: 'java',
		type: 'single',
		difficulty: 'hard',
		category: '面向对象编程',
		question: 'Java中，以下关于组合和继承的说法，正确的是？',
		options: [
			{ key: 'A', text: '继承关系是"is-a"，组合关系是"has-a"' },
			{ key: 'B', text: '组合比继承更灵活' },
			{ key: 'C', text: '优先使用组合而非继承' },
			{ key: 'D', text: '以上都对' }
		],
		answer: ['D'],
		explanation: '继承是"is-a"关系，组合是"has-a"关系。组合更灵活，可以动态改变。设计原则：优先使用组合而非继承。'
	},
	{
		id: 2029,
		techId: 'java',
		type: 'single',
		difficulty: 'hard',
		category: '面向对象编程',
		question: 'Java中，以下关于单例模式的说法，错误的是？',
		options: [
			{ key: 'A', text: '饿汉式在类加载时创建实例' },
			{ key: 'B', text: '懒汉式需要双重检查锁定' },
			{ key: 'C', text: '枚举单例是最安全的实现方式' },
			{ key: 'D', text: '单例模式可以创建多个实例' }
		],
		answer: ['D'],
		explanation: '单例模式确保一个类只有一个实例。饿汉式类加载时创建，懒汉式需要同步，枚举单例线程安全且防反射。'
	},
	{
		id: 2030,
		techId: 'java',
		type: 'multiple',
		difficulty: 'hard',
		category: '面向对象编程',
		question: '以下哪些是面向对象设计原则？',
		options: [
			{ key: 'A', text: '单一职责原则（SRP）' },
			{ key: 'B', text: '开闭原则（OCP）' },
			{ key: 'C', text: '里氏替换原则（LSP）' },
			{ key: 'D', text: '依赖倒置原则（DIP）' }
		],
		answer: ['A', 'B', 'C', 'D'],
		explanation: 'SOLID原则：单一职责、开闭原则、里氏替换、接口隔离、依赖倒置。这些原则指导面向对象设计。'
	}
];

